package com.malou.client.ventas.cambio;

import java.util.List;

import com.extjs.gxt.ui.client.data.BaseFilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.BaseListLoader;
import com.extjs.gxt.ui.client.data.BasePagingLoadConfig;
import com.extjs.gxt.ui.client.data.BasePagingLoader;
import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.data.BeanModelReader;
import com.extjs.gxt.ui.client.data.FilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.ListLoadResult;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.PagingLoadResult;
import com.extjs.gxt.ui.client.data.PagingLoader;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.malou.client.MalouConstants;
import com.malou.client.util.MensajeData;
import com.malou.client.util.Utilities;
import com.malou.client.ventas.ingresostock.IngresoStock;
import com.malou.client.ventas.modeloprenda.IngresoaOfertaDialog;
import com.malou.client.ventas.salidastock.SalidaStock;


public class Cambios {
	private static CambioServiceAsync cs = GWT.create(CambioService.class);
	private static MalouConstants constants = GWT.create(MalouConstants.class);	
	protected static CambioDialog cambioDialog;
	protected static IngresoaOfertaDialog ingresoaofertaDialog;
	
	public static DevolucionPrendaDialog devolucionprendaDialog;
	
	public static PagingLoader<PagingLoadResult<ModelData>> loader;
	public static ListStore<BeanModel> store;
	
	public static PagingLoader<PagingLoadResult<ModelData>> loaderDevolucion;
	public static ListStore<BeanModel> storeDevolucion;
	
	public static BaseListLoader<ListLoadResult<ModelData>> loaderListIngresoStock;
	public static ListStore<BeanModel> storeListIngresoStock;

	public static BaseListLoader<ListLoadResult<ModelData>> loaderListSalidaStock;
	public static ListStore<BeanModel> storeListSalidaStock;

	public static BaseListLoader<ListLoadResult<ModelData>> loaderListDevolucion;
	public static ListStore<BeanModel> storeListDevolucion;
	
	
		
	static Integer cambio_id;

	public static void getPaginate() {
		RpcProxy<PagingLoadResult<Cambio>> proxy = new RpcProxy<PagingLoadResult<Cambio>>() {

			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<PagingLoadResult<Cambio>> callback) {
				cs.paginateCambio((FilterPagingLoadConfig) loadConfig, callback);  
				
			}  
	      
	    };
	
	    loader = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader()){  
	        @Override  
	        protected Object newLoadConfig() {  
	          BasePagingLoadConfig config = new BaseFilterPagingLoadConfig();  
	          return config;  
	        }  
	    
	      };  
        loader.setRemoteSort(true);  
      
        store = new ListStore<BeanModel>(loader);		
	}
	
	public static void getPaginateDevoluciones() {
		RpcProxy<PagingLoadResult<Cambio>> proxy = new RpcProxy<PagingLoadResult<Cambio>>() {

			@Override
			protected void load(Object loadConfig,
			      AsyncCallback<PagingLoadResult<Cambio>> callback) {
				cs.paginateDevolucion((FilterPagingLoadConfig) loadConfig, callback);  
				
			}  
	      
	    };
	
	    loaderDevolucion = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader()){  
	        @Override  
	        protected Object newLoadConfig() {  
	          BasePagingLoadConfig config = new BaseFilterPagingLoadConfig();  
	          return config;  
	        }  
	    
	      };  
        loaderDevolucion.setRemoteSort(true);  
      
        storeDevolucion = new ListStore<BeanModel>(loaderDevolucion);		
	}
	
	
	public static void getListIngresoStock(){
		RpcProxy<List<IngresoStock>> proxy = new RpcProxy<List<IngresoStock>>(){

			@Override
			protected void load(Object loadConfig,
					AsyncCallback<List<IngresoStock>> callback) {
				cs.getListIngresoStock(cambio_id, callback);
			}
		};
		loaderListIngresoStock = new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
		storeListIngresoStock  = new ListStore<BeanModel>(loaderListIngresoStock);
	}
	
	public static void getListSalidaStock(){
		RpcProxy<List<SalidaStock>> proxy = new RpcProxy<List<SalidaStock>>(){

			@Override
			protected void load(Object loadConfig,
					AsyncCallback<List<SalidaStock>> callback) {
				cs.getListSalidaStock(cambio_id, callback);
	    	}
		};
		loaderListSalidaStock = new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
		storeListSalidaStock  = new ListStore<BeanModel>(loaderListSalidaStock);
	}
	
	public static void getListDevoluciones(){
		RpcProxy<List<Cambio>> proxy = new RpcProxy<List<Cambio>>(){

			@Override
			protected void load(Object loadConfig,
					AsyncCallback<List<Cambio>> callback) {
				cs.getListDevoluciones(callback);
	    	}
		};
		loaderListDevolucion = new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
		storeListDevolucion  = new ListStore<BeanModel>(loaderListDevolucion);
	}
                                         
	public static void save(Cambio c,List<IngresoStock> listIngreso,List<SalidaStock> listSalida) {
		
		cs.save(c, listIngreso, listSalida, new AsyncCallback<MensajeData>()  {

			@Override
			public void onFailure(Throwable caught) {				
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);	
				store.rejectChanges();
			}    

			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {
					cambioDialog.hide();					
					loader.load(0, Utilities.itemsPerPage);
				}
				 else {
					 
					 String msg = constants.cambioNoGuardado();
					 MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
				}		
				cambioDialog.status.hide();
				cambioDialog.getButtonBar().enable();
			}
			
		});		
	}
	
	
	public static void save(Cambio cam,List<IngresoStock> lis){
		cs.save(cam, lis, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);
				store.rejectChanges();
			}

			@Override
			public void onSuccess(MensajeData result) {
				if (result.guardado) {
					devolucionprendaDialog.hide();
					loader.load(0, Utilities.itemsPerPage);
				}
				 else {
					 String msg = constants.stockPrendaNoGuardado();
					 MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
				}
				 devolucionprendaDialog.status.hide();
				 devolucionprendaDialog.getButtonBar().enable();
			 }
			
		});
	}

}
